// 导入数据库连接实例（已初始化的 Sequelize 实例）
const sequelize = require("../config/db");

// 导入所有模型定义（与数据库表一一对应）
const AlarmRecord = require("./alarmRecord");
const Channel = require("./channel");
const Equipment = require("./equipment");
const EquipmentTemplate = require("./equipmentTemplate");
const Feature = require("./feature");
const GaugingPoint = require("./gaugingPoint");
const GaugingPointTemplate = require("./gaugingPointTemplate");
const OperatingCondition = require("./operatingCondition");
const OperatingConditionTemplate = require("./operatingConditionTemplate");
const Record = require("./record");
const Target = require("./target");
const TargetTemplate = require("./targetTemplate");
const User = require("./user");

/**
 * 模型间关联关系定义
 * 遵循原则：
 * 1. 严格对应数据库表的外键约束（ON DELETE / ON UPDATE）
 * 2. 明确关联别名（as），方便查询时使用
 * 3. 一对多关系中，父模型使用hasMany，子模型使用belongsTo
 * 4. 外键名称与数据库保持一致，避免混淆
 */

// ---------------------------- User 模型关联 ----------------------------
// 一个用户可以创建多个设备模板（一对多）
// 约束：禁止删除有设备模板的用户（RESTRICT），用户ID更新时同步更新子表（CASCADE）
User.hasMany(EquipmentTemplate, {
  foreignKey: "create_user_id", // 对应设备模板表的创建人外键
  as: "equipmentTemplates", // 关联查询别名
  onDelete: "RESTRICT", // 数据库约束：禁止删除
  onUpdate: "CASCADE", // 数据库约束：级联更新
});

// 一个用户可以创建多个设备（一对多）
// 约束：禁止删除有设备的用户（RESTRICT），用户ID更新时同步更新子表（CASCADE）
User.hasMany(Equipment, {
  foreignKey: "create_user_id", // 对应设备表的创建人外键
  as: "equipments", // 关联查询别名
  onDelete: "RESTRICT", // 数据库约束：禁止删除
  onUpdate: "CASCADE", // 数据库约束：级联更新
});

// 一个用户可以创建多个采集记录（一对多）
// 约束：禁止删除有采集记录的用户（RESTRICT），用户ID更新时同步更新子表（CASCADE）
User.hasMany(Record, {
  foreignKey: "create_user_id", // 对应采集记录表的创建人外键
  as: "records", // 关联查询别名
  onDelete: "RESTRICT", // 数据库约束：禁止删除
  onUpdate: "CASCADE", // 数据库约束：级联更新
});

// 一个用户可以处理多个报警记录（一对多）
// 约束：禁止删除有处理记录的用户（RESTRICT），用户ID更新时同步更新子表（CASCADE）
User.hasMany(AlarmRecord, {
  foreignKey: "processing_user_id", // 对应报警记录表的处理人外键
  as: "processedAlarms", // 关联查询别名
  onDelete: "RESTRICT", // 数据库约束：禁止删除
  onUpdate: "CASCADE", // 数据库约束：级联更新
});

// 一个用户可以拥有多个报警记录（一对多，报警归属关系）
// 约束：禁止删除有归属报警的用户（RESTRICT），用户ID更新时同步更新子表（CASCADE）
User.hasMany(AlarmRecord, {
  foreignKey: "user_id", // 对应报警记录表的归属用户外键
  as: "ownedAlarms", // 关联查询别名
  onDelete: "RESTRICT", // 数据库约束：禁止删除
  onUpdate: "CASCADE", // 数据库约束：级联更新
});

// ---------------------------- EquipmentTemplate 模型关联 ----------------------------
// 设备模板属于一个创建者（多对一）
EquipmentTemplate.belongsTo(User, {
  foreignKey: "create_user_id", // 对应创建人外键
  as: "creator", // 关联查询别名（查询设备模板时可通过creator获取创建者信息）
  onDelete: "RESTRICT", // 同User.hasMany(EquipmentTemplate)约束
  onUpdate: "CASCADE",
});

// 一个设备模板可以生成多个设备实例（一对多）
EquipmentTemplate.hasMany(Equipment, {
  foreignKey: "equipment_template_id", // 对应设备表的模板外键
  as: "equipments", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有设备实例的模板
  onUpdate: "CASCADE",
});

// 一个设备模板可以有多个测点模板（一对多）
EquipmentTemplate.hasMany(GaugingPointTemplate, {
  foreignKey: "equipment_template_id", // 对应测点模板表的设备模板外键
  as: "gaugingPointTemplates", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有测点模板的设备模板
  onUpdate: "CASCADE",
});

// 一个设备模板可以有多个工况模板（一对多）
EquipmentTemplate.hasMany(OperatingConditionTemplate, {
  foreignKey: "equipment_template_id", // 对应工况模板表的设备模板外键
  as: "operatingConditionTemplates", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有工况模板的设备模板
  onUpdate: "CASCADE",
});

// ---------------------------- Equipment 模型关联 ----------------------------
// 设备属于一个创建者（多对一）
Equipment.belongsTo(User, {
  foreignKey: "create_user_id", // 对应创建人外键
  as: "creator", // 关联查询别名
  onDelete: "RESTRICT", // 同User.hasMany(Equipment)约束
  onUpdate: "CASCADE",
});

// 设备基于一个设备模板（多对一）
Equipment.belongsTo(EquipmentTemplate, {
  foreignKey: "equipment_template_id", // 对应设备模板外键
  as: "equipmentTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除被设备引用的模板
  onUpdate: "CASCADE",
});

// 一个设备可以有多个测点（一对多）
// 约束：删除设备时级联删除其下测点（CASCADE），设备ID更新时同步更新子表
Equipment.hasMany(GaugingPoint, {
  foreignKey: "equipment_id", // 对应测点表的设备外键
  as: "gaugingPoints", // 关联查询别名
  onDelete: "CASCADE", // 数据库约束：级联删除
  onUpdate: "CASCADE",
});

// 一个设备可以有多个工况（一对多）
// 约束：删除设备时级联删除其下工况（CASCADE）
Equipment.hasMany(OperatingCondition, {
  foreignKey: "equipment_id", // 对应工况表的设备外键
  as: "operatingConditions", // 关联查询别名
  onDelete: "CASCADE", // 数据库约束：级联删除
  onUpdate: "CASCADE",
});

// 一个设备可以有多个采集记录（一对多）
Equipment.hasMany(Record, {
  foreignKey: "equipment_id", // 对应采集记录表的设备外键
  as: "records", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有采集记录的设备
  onUpdate: "CASCADE",
});

// 一个设备可以有多个报警记录（一对多）
Equipment.hasMany(AlarmRecord, {
  foreignKey: "equipment_id", // 对应报警记录表的设备外键
  as: "alarmRecords", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有报警记录的设备
  onUpdate: "CASCADE",
});

// ---------------------------- GaugingPointTemplate 模型关联 ----------------------------
// 测点模板属于一个设备模板（多对一）
GaugingPointTemplate.belongsTo(EquipmentTemplate, {
  foreignKey: "equipment_template_id", // 对应设备模板外键
  as: "equipmentTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 同EquipmentTemplate.hasMany约束
  onUpdate: "CASCADE",
});

// 一个测点模板可以生成多个测点实例（一对多）
GaugingPointTemplate.hasMany(GaugingPoint, {
  foreignKey: "gauging_point_template_id", // 对应测点表的模板外键
  as: "gaugingPoints", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有测点实例的模板
  onUpdate: "CASCADE",
});

// 一个测点模板可以有多个指标模板（一对多）
GaugingPointTemplate.hasMany(TargetTemplate, {
  foreignKey: "gauging_point_template_id", // 对应指标模板表的测点模板外键
  as: "targetTemplates", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有指标模板的测点模板
  onUpdate: "CASCADE",
});

// ---------------------------- GaugingPoint 模型关联 ----------------------------
// 测点属于一个设备（多对一）
GaugingPoint.belongsTo(Equipment, {
  foreignKey: "equipment_id", // 对应设备外键
  as: "equipment", // 关联查询别名
  onDelete: "CASCADE", // 同Equipment.hasMany(GaugingPoint)约束（级联删除）
  onUpdate: "CASCADE",
});

// 测点基于一个测点模板（多对一）
GaugingPoint.belongsTo(GaugingPointTemplate, {
  foreignKey: "gauging_point_template_id", // 对应测点模板外键
  as: "gaugingPointTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除被测点引用的模板
  onUpdate: "CASCADE",
});

// 一个测点可以有多个指标（一对多）
// 约束：删除测点时级联删除其下指标（CASCADE）
GaugingPoint.hasMany(Target, {
  foreignKey: "gauging_point_id", // 对应指标表的测点外键
  as: "targets", // 关联查询别名
  onDelete: "CASCADE", // 数据库约束：级联删除
  onUpdate: "CASCADE",
});

// 一个测点可以有多个采集记录（一对多）
GaugingPoint.hasMany(Record, {
  foreignKey: "gauging_point_id", // 对应采集记录表的测点外键
  as: "records", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有采集记录的测点
  onUpdate: "CASCADE",
});

// 一个测点可以有多个报警记录（一对多）
GaugingPoint.hasMany(AlarmRecord, {
  foreignKey: "gauging_point_id", // 对应报警记录表的测点外键
  as: "alarmRecords", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有报警记录的测点
  onUpdate: "CASCADE",
});

// ---------------------------- OperatingConditionTemplate 模型关联 ----------------------------
// 工况模板属于一个设备模板（多对一）
OperatingConditionTemplate.belongsTo(EquipmentTemplate, {
  foreignKey: "equipment_template_id", // 对应设备模板外键
  as: "equipmentTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 同EquipmentTemplate.hasMany约束
  onUpdate: "CASCADE",
});

// 一个工况模板可以生成多个工况实例（一对多）
OperatingConditionTemplate.hasMany(OperatingCondition, {
  foreignKey: "operating_condition_template_id", // 对应工况表的模板外键
  as: "operatingConditions", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有工况实例的模板
  onUpdate: "CASCADE",
});

// 一个工况模板可以有多个指标模板（一对多）
OperatingConditionTemplate.hasMany(TargetTemplate, {
  foreignKey: "operating_condition_template_id", // 对应指标模板表的工况模板外键
  as: "targetTemplates", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有指标模板的工况模板
  onUpdate: "CASCADE",
});

// ---------------------------- OperatingCondition 模型关联 ----------------------------
// 工况属于一个设备（多对一）
OperatingCondition.belongsTo(Equipment, {
  foreignKey: "equipment_id", // 对应设备外键
  as: "equipment", // 关联查询别名
  onDelete: "CASCADE", // 同Equipment.hasMany(OperatingCondition)约束（级联删除）
  onUpdate: "CASCADE",
});

// 工况基于一个工况模板（多对一）
OperatingCondition.belongsTo(OperatingConditionTemplate, {
  foreignKey: "operating_condition_template_id", // 对应工况模板外键
  as: "operatingConditionTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除被工况引用的模板
  onUpdate: "CASCADE",
});

// 一个工况可以有多个指标（一对多）
// 约束：删除工况时级联删除其下指标（CASCADE）
OperatingCondition.hasMany(Target, {
  foreignKey: "operating_condition_id", // 对应指标表的工况外键
  as: "targets", // 关联查询别名
  onDelete: "CASCADE", // 数据库约束：级联删除
  onUpdate: "CASCADE",
});

// 一个工况可以有多个采集记录（一对多）
OperatingCondition.hasMany(Record, {
  foreignKey: "operating_condition_id", // 对应采集记录表的工况外键
  as: "records", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有采集记录的工况
  onUpdate: "CASCADE",
});

// 一个工况可以有多个报警记录（一对多）
OperatingCondition.hasMany(AlarmRecord, {
  foreignKey: "operating_condition_id", // 对应报警记录表的工况外键
  as: "alarmRecords", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有报警记录的工况
  onUpdate: "CASCADE",
});

// ---------------------------- TargetTemplate 模型关联 ----------------------------
// 指标模板属于一个测点模板（多对一）
TargetTemplate.belongsTo(GaugingPointTemplate, {
  foreignKey: "gauging_point_template_id", // 对应测点模板外键
  as: "gaugingPointTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 同GaugingPointTemplate.hasMany约束
  onUpdate: "CASCADE",
});

// 指标模板属于一个工况模板（多对一）
TargetTemplate.belongsTo(OperatingConditionTemplate, {
  foreignKey: "operating_condition_template_id", // 对应工况模板外键
  as: "operatingConditionTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 同OperatingConditionTemplate.hasMany约束
  onUpdate: "CASCADE",
});

// 一个指标模板可以生成多个指标实例（一对多）
TargetTemplate.hasMany(Target, {
  foreignKey: "target_template_id", // 对应指标表的模板外键
  as: "targets", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有指标实例的模板
  onUpdate: "CASCADE",
});

// ---------------------------- Target 模型关联 ----------------------------
// 指标属于一个测点（多对一）
Target.belongsTo(GaugingPoint, {
  foreignKey: "gauging_point_id", // 对应测点外键
  as: "gaugingPoint", // 关联查询别名
  onDelete: "CASCADE", // 同GaugingPoint.hasMany(Target)约束（级联删除）
  onUpdate: "CASCADE",
});

// 指标属于一个工况（多对一）
Target.belongsTo(OperatingCondition, {
  foreignKey: "operating_condition_id", // 对应工况外键
  as: "operatingCondition", // 关联查询别名
  onDelete: "CASCADE", // 同OperatingCondition.hasMany(Target)约束（级联删除）
  onUpdate: "CASCADE",
});

// 指标基于一个指标模板（多对一）
Target.belongsTo(TargetTemplate, {
  foreignKey: "target_template_id", // 对应指标模板外键
  as: "targetTemplate", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除被指标引用的模板
  onUpdate: "CASCADE",
});

// 一个指标可以有多个特征数据（一对多）
Target.hasMany(Feature, {
  foreignKey: "target_id", // 对应特征表的指标外键
  as: "features", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有特征数据的指标
  onUpdate: "CASCADE",
});

// 一个指标可以有多个报警记录（一对多）
Target.hasMany(AlarmRecord, {
  foreignKey: "target_id", // 对应报警记录表的指标外键
  as: "alarmRecords", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有报警记录的指标
  onUpdate: "CASCADE",
});

// ---------------------------- Record 模型关联 ----------------------------
// 采集记录由一个用户创建（多对一）
Record.belongsTo(User, {
  foreignKey: "create_user_id", // 对应创建人外键
  as: "creator", // 关联查询别名
  onDelete: "RESTRICT", // 同User.hasMany(Record)约束
  onUpdate: "CASCADE",
});

// 采集记录属于一个设备（多对一）
Record.belongsTo(Equipment, {
  foreignKey: "equipment_id", // 对应设备外键
  as: "equipment", // 关联查询别名
  onDelete: "RESTRICT", // 同Equipment.hasMany(Record)约束
  onUpdate: "CASCADE",
});

// 采集记录属于一个测点（多对一）
Record.belongsTo(GaugingPoint, {
  foreignKey: "gauging_point_id", // 对应测点外键
  as: "gaugingPoint", // 关联查询别名
  onDelete: "RESTRICT", // 同GaugingPoint.hasMany(Record)约束
  onUpdate: "CASCADE",
});

// 采集记录属于一个工况（多对一）
Record.belongsTo(OperatingCondition, {
  foreignKey: "operating_condition_id", // 对应工况外键
  as: "operatingCondition", // 关联查询别名
  onDelete: "RESTRICT", // 同OperatingCondition.hasMany(Record)约束
  onUpdate: "CASCADE",
});

// 一个采集记录可以有多个通道（一对多）
// 约束：删除采集记录时级联删除其下通道（CASCADE）
Record.hasMany(Channel, {
  foreignKey: "record_id", // 对应通道表的采集记录外键
  as: "channels", // 关联查询别名
  onDelete: "CASCADE", // 数据库约束：级联删除
  onUpdate: "CASCADE",
});

// 一个采集记录可以有多个报警记录（一对多）
Record.hasMany(AlarmRecord, {
  foreignKey: "record_id", // 对应报警记录表的采集记录外键
  as: "alarmRecords", // 关联查询别名
  onDelete: "RESTRICT", // 禁止删除有报警记录的采集记录
  onUpdate: "CASCADE",
});

// ---------------------------- Channel 模型关联 ----------------------------
// 通道属于一个采集记录（多对一）
Channel.belongsTo(Record, {
  foreignKey: "record_id", // 对应采集记录外键
  as: "record", // 关联查询别名
  onDelete: "CASCADE", // 同Record.hasMany(Channel)约束（级联删除）
  onUpdate: "CASCADE",
});

// 一个通道可以有多个特征数据（一对多）
// 约束：删除通道时级联删除其下特征数据（CASCADE）
Channel.hasMany(Feature, {
  foreignKey: "channel_id", // 对应特征表的通道外键
  as: "features", // 关联查询别名
  onDelete: "CASCADE", // 数据库约束：级联删除
  onUpdate: "CASCADE",
});

// ---------------------------- Feature 模型关联 ----------------------------
// 特征数据属于一个通道（多对一）
Feature.belongsTo(Channel, {
  foreignKey: "channel_id", // 对应通道外键
  as: "channel", // 关联查询别名
  onDelete: "CASCADE", // 同Channel.hasMany(Feature)约束（级联删除）
  onUpdate: "CASCADE",
});

// 特征数据属于一个指标（多对一）
Feature.belongsTo(Target, {
  foreignKey: "target_id", // 对应指标外键
  as: "target", // 关联查询别名
  onDelete: "RESTRICT", // 同Target.hasMany(Feature)约束
  onUpdate: "CASCADE",
});

// ---------------------------- AlarmRecord 模型关联 ----------------------------
// 报警记录属于一个用户（归属关系，多对一）
AlarmRecord.belongsTo(User, {
  foreignKey: "user_id", // 对应归属用户外键
  as: "owner", // 关联查询别名（报警归属的用户）
  onDelete: "RESTRICT", // 同User.hasMany(AlarmRecord)约束（ownedAlarms）
  onUpdate: "CASCADE",
});

// 报警记录属于一个设备（多对一）
AlarmRecord.belongsTo(Equipment, {
  foreignKey: "equipment_id", // 对应设备外键
  as: "equipment", // 关联查询别名
  onDelete: "RESTRICT", // 同Equipment.hasMany(AlarmRecord)约束
  onUpdate: "CASCADE",
});

// 报警记录属于一个测点（多对一）
AlarmRecord.belongsTo(GaugingPoint, {
  foreignKey: "gauging_point_id", // 对应测点外键
  as: "gaugingPoint", // 关联查询别名
  onDelete: "RESTRICT", // 同GaugingPoint.hasMany(AlarmRecord)约束
  onUpdate: "CASCADE",
});

// 报警记录属于一个工况（多对一）
AlarmRecord.belongsTo(OperatingCondition, {
  foreignKey: "operating_condition_id", // 对应工况外键
  as: "operatingCondition", // 关联查询别名
  onDelete: "RESTRICT", // 同OperatingCondition.hasMany(AlarmRecord)约束
  onUpdate: "CASCADE",
});

// 报警记录属于一个采集记录（多对一）
AlarmRecord.belongsTo(Record, {
  foreignKey: "record_id", // 对应采集记录外键
  as: "record", // 关联查询别名
  onDelete: "RESTRICT", // 同Record.hasMany(AlarmRecord)约束
  onUpdate: "CASCADE",
});

// 报警记录属于一个指标（多对一）
AlarmRecord.belongsTo(Target, {
  foreignKey: "target_id", // 对应指标外键
  as: "target", // 关联查询别名
  onDelete: "RESTRICT", // 同Target.hasMany(AlarmRecord)约束
  onUpdate: "CASCADE",
});

// 报警记录由一个用户处理（多对一）
AlarmRecord.belongsTo(User, {
  foreignKey: "processing_user_id", // 对应处理人外键
  as: "processingUser", // 关联查询别名（处理报警的用户）
  onDelete: "RESTRICT", // 同User.hasMany(AlarmRecord)约束（processedAlarms）
  onUpdate: "CASCADE",
});

// 导出所有模型和数据库连接实例，供其他模块使用
module.exports = {
  sequelize,
  User,
  EquipmentTemplate,
  Equipment,
  GaugingPointTemplate,
  GaugingPoint,
  OperatingConditionTemplate,
  OperatingCondition,
  TargetTemplate,
  Target,
  Record,
  Channel,
  Feature,
  AlarmRecord,
};
